// Copyright (c) 2005  INRIA Sophia-Antipolis (France).
// All rights reserved.
//
// This file is part of cgal-python; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; version 2.1 of the License.
// See the file LICENSE.LGPL distributed with cgal-python.
//
// Licensees holding a valid commercial license may use this file in
// accordance with the commercial license agreement provided with the software.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
//
// $Id: Py_Min_annulus_d_doc.h 125 2006-06-06 16:27:38Z nmeskini $
// $URL: svn+ssh://scm.gforge.inria.fr/svn/cgal-python/trunk/cgal-python/bindings/Geometric_Optimisation/Py_Min_annulus_d_doc.h $
//
// Author(s)     : Naceur Meskini
//=========================================================================
#ifndef MIN_ANNULUS_DOCS_H
#define MIN_ANNULUS_DOCS_H
//=======================================================
// doc of Min_annulus_d class
//=======================================================

const char * Min_annulus_2_doc =  "\
An object of the class Min_annulus_2 is the unique annulus\n\
(region between two concentric circles with radius r and R, r <= R)\n\
enclosing a finite set of points in 2-dimensional Euclidean space ExE,n\n\
where the difference R**2-r**2 is minimal.\n\
For a point set P we denote by ma(P) the smallest annulus that contains all points of P. \n\
An inclusion-minimal subset S of P with ma(S)=ma(P) is called a support set, \n\
the points in S are the support points. A support set has size at most d+2, \n\
and all its points lie on the boundary of ma(P). In general, the support set is not necessarily unique.\n\
The underlying algorithm can cope with all kinds of input, e.g. P may be empty or points may occur more than once.\n\
The algorithm computes a support set S which remains fixed until the next set, insert, or clear operation.\n\
For more details see the C++ doc:\n\
http://www.cgal.org/Manual/3.2/doc_html/cgal_manual/Optimisation_ref/Class_Min_annulus_d.html";

const char * init_2_doc =  "\
	min_annulus = Min_annulus_2()\nCreation of an object of Min_annulus_2";

const char * init_3_doc =  "\
	min_annulus = Min_annulus_3()\nCreation of an object of Min_annulus_3";

const char * ambient_dimension_doc =  "\
	min_annulus.ambient_dimension( self ) -> int\n\
	returns the dimension of the points in P. \n\
	If min_annulus is empty, the ambient dimension is -1.";

const char * number_of_points_doc =  "\
	min_annulus.number_of_points( self ) -> int\n\
	returns the number of points of min_annulus, i.e. |P|.";

const char * points_doc =  "\
";

const char * number_of_support_points_doc =  "\
	min_annulus.number_of_support_points (self) -> int\n\
	returns the number of support points of min_annulus, i.e. |S|.";

const char * number_of_inner_support_points_doc =  "\
	min_annulus.number_of_inner_support_points( self ) -> int\n\
	returns the number of support points of min_annulus which lie on the inner sphere.";

const char * number_of_outer_support_points_doc =  "\
	min_annulus.number_of_outer_support_points( self ) -> int\n\
	returns the number of support points of min_annulus which lie on the outer sphere.";

const char * inner_support_points_doc =  "\
";

const char * outer_support_points_doc =  "\
";
const char * center_coordinates_doc =  "\
";

const char * squared_inner_radius_numerator_doc =  "\
	min_annulus.squared_inner_radius_numerator( self ) -> double\n\
	returns the numerator of the squared inner radius of min_annulus.";
const char * squared_outer_radius_numerator_doc =  "\
	min_annulus.squared_outer_radius_numerator( self ) -> double\n\
	returns the numerator of the squared outer radius of min_annulus.";

const char * squared_radii_denominator_doc =  "\
	min_annulus.squared_radii_denominator( self ) -> double\n\
	returns the denominator of the squared radii of min_annulus.";

const char * center_doc =  "\
	min_annulus.center( self ) -> Point\n\
	returns the center of min_annulus.\n\
	Precondition: min_annulus is not empty.";

const char * squared_inner_radius_doc =  "\
	min_annulus.squared_inner_radius( self ) -> double\n\
	returns the squared inner radius of min_annulus.\n\
	Precondition: min_annulus is not empty.";

const char * squared_outer_radius_doc =  "\
	min_annulus.squared_outer_radius( self ) -> double\n\
	returns the squared outer radius of min_annulus.\n\
	Precondition: min_annulus is not empty.";

const char * bounded_side_doc =  "\
	min_annulus.bounded_side( self ,Point p) -> Bounded_side\n\
	returns Kernel.ON_BOUNDED_SIDE, Kernel.ON_BOUNDARY, or\n\
 	Kernel.ON_UNBOUNDED_SIDE iff p lies properly inside, on the\n\
 	boundary, or properly outside of min_annulus, resp.\n\
	Precondition: The dimension of p equals min_annulus.ambient_dimension() if min_annulus is not empty.";

const char * has_on_bounded_side_doc =  "\
	min_annulus.has_on_bounded_side( self ,Point p) -> bool\n\
	returns true, iff p lies properly inside min_annulus.\n\
	Precondition: The dimension of p equals  min_annulus.ambient_dimension() \n\
	if min_annulus is not empty.";

const char * has_on_boundary_doc =  "\
	min_annulus.has_on_boundary( self , Point p) -> bool\n\
	returns true, iff p lies on the boundary of min_annulus.\n\
	Precondition: The dimension of p equals min_annulus.ambient_dimension() \nif min_annulus is not empty.";

const char * has_on_unbounded_side_doc =  "\
	min_annulus.has_on_unbounded_side( self ,Point p) -> bool\n\
	returns true, iff p lies properly outside of min_annulus.\n\
	Precondition: The dimension of p equals min_annulus.ambient_dimension() \nif min_annulus is not empty.";

const char * is_empty_doc =  "\
	min_annulus.is_empty( self) -> bool\n\
	returns true, iff min_annulus is empty (this implies degeneracy).";

const char * is_degenerate_doc =  "\
	min_annulus.is_degenerate( self) -> bool\n\
	returns true, iff min_annulus is degenerate, \ni.e. if min_annulus is empty or equal to a single point.";

const char * clear_doc =  "\
	min_annulus.clear( self ) -> void\n\
	resets min_annulus to ma(Ø).";

const char * insert_doc =  "\
	min_annulus.insert( self , Point p) -> void\n\
	inserts p into min_annulus.\n\
	Precondition: The dimension of p equals min_annulus.ambient_dimension() \nif min_annulus is not empty.";

const char * is_valid_doc =  "\
	min_annulus.is_valid( self , bool verbose = false,int level = 0) -> bool\n\
	returns true, iff min_annulus is valid. \n\
	If verbose is true, some messages concerning the performed checks are written to standard error stream. \n\
	The second parameter level is not used, we provide it only\nfor consistency with interfaces of other classes.";

const char * Min_annulus_3_doc =  "\
An object of the class Min_annulus_3 is the unique annulus\n\
(region between two concentric spheres with radius r and R, r <= R)\n\
enclosing a finite set of points in 3-dimensional Euclidean space ExExE,n\n\
where the difference R**2-r**2 is minimal.\n\
For a point set P we denote by ma(P) the smallest annulus that contains all points of P. \n\
An inclusion-minimal subset S of P with ma(S)=ma(P) is called a support set, \n\
the points in S are the support points. A support set has size at most d+2, \n\
and all its points lie on the boundary of ma(P). In general, the support set is not necessarily unique.\n\
The underlying algorithm can cope with all kinds of input, e.g. P may be empty or points may occur more than once.\n\
The algorithm computes a support set S which remains fixed until the next set, insert, or clear operation.\n\
For more details see the C++ doc:\n\
http://www.cgal.org/Manual/3.2/doc_html/cgal_manual/Optimisation_ref/Class_Min_annulus_d.html";


#endif //MIN_ANNULUS_DOCS_H



